class Permissao < ActiveRecord::Base
 
 @@count_gravar = 0
 @@count_gravar_novo = 0

 belongs_to :papel 
 belongs_to :grupo
 belongs_to :conteudo

 def self.permissoes_para_conteudo(conteudo_id)
   # busca apenas as permissoes de papeis específicos aos conteúdos.
   @permissoes = Permissao.find(:all,
                                  :conditions=>'conteudo_id = ' << conteudo_id.to_s,
                                  :joins=>'INNER JOIN papel as pap on permissao.papel_id = pap.id AND pap.especifico_conteudo = 1' )
 end

 def self.permissoes_para_conteudo_indexadas(conteudo_id)
   ind = {}
   self.permissoes_para_conteudo(conteudo_id).each do |pe|
     ind[pe.grupo_id] = {} if (ind[pe.grupo_id].nil?)
     ind[pe.grupo_id][pe.papel_id] = pe
   end
   ind
 end
 
 def self.cria_permissoes_novo_conteudo(conteudo)
    @grupos = CaGrupo.find(:all)
    @papeis = CaPapel.find(:all,:conditions=>'especifico_conteudo = 1')
    @grupos.each do |g|
      @papeis.each do |pa|
        #### cria para esse conteudo, grupo e papel uma permissão que herda das do pai desse conteudo. 
        permissao = CaPermissao.new({
                                       'grupo_id' => g.id,
                                       'papel_id' => pa.id,
                                       'conteudo_id' => conteudo.id,
                                       'herdar' => true,
                                       'tem_acesso' => nil
                                     })
        permissao.herdar_valor()
        permissao.gravar
      end
    end
 end

 def self.cria_permissoes_novo_papel(papel)
   @grupos = Grupo.find(:all)
   @conteudos = Conteudo.find_by_sql("select id,parent_id from conteudo")
   @conteudos.each do |c|
     if(c.parent_id == nil)
       herdar = false
     else
       herdar = true
     end
     tem_acesso = false
     @grupos.each do |g|
       permissao = Permissao.create({
                                       'grupo_id' => g.id,
                                       'papel_id' => papel.id,
                                       'conteudo_id' => c.id,
                                       'herdar' => herdar,
                                       'tem_acesso' => tem_acesso
                                     })
     end
   end
 end

 def self.cria_permissoes_novo_grupo(grupo)
   @papeis = Papel.find(:all,:conditions=>'especifico_conteudo = 1')
   @conteudos = Conteudo.find_by_sql("select id,parent_id from conteudo")
   @conteudos.each do |c|
     if(c.parent_id == nil)
       herdar = false
     else
       herdar = true
     end
     tem_acesso = false
     @papeis.each do |pap|
       permissao = Permissao.create({
                                       'grupo_id' => grupo.id,
                                       'papel_id' => pap.id,
                                       'conteudo_id' => c.id,
                                       'herdar' => herdar,
                                       'tem_acesso' => tem_acesso
                                     })
     end
   end
 end

 def self.remover_todas_permissoes_papel(papel)
   Permissao.delete_all(["papel_id = ?",papel.id])
 end

 def self.remover_todas_permissoes_conteudo(conteudo)
   Permissao.delete_all(["conteudo_id = ?",conteudo.id])
 end

 def self.remover_todas_permissoes_grupo(grupo)
   Permissao.delete_all(["grupo_id = ?",grupo.id])
 end
 
 def self.inicializar_permissoes_conteudo_inexistentes(permissoes, grupos, papeis, conteudo_id)
   #grupos.each do |g|
     #papeis.each do |pa|
       #if(permissoes[g.id].nil? || permissoes[g.id][pa.id].nil?)
        # permissoes[g.id] = {} if(permissoes[g.id].nil?)
         #permissoes[g.id][pa.id] =  CaPermissao.new({
          #                             'ca_grupo_id' => g.id,
           #                            'ca_papel_id' => pa.id,
            #                           'conteudo_id' => conteudo_id,
             #                          'herdar' => true,
              #                         'tem_acesso' => nil
               #                      })
       #end
     #end
   #end
   permissoes
 end
 
 def nova?
   @new_record
 end

 ###################### atualiza��es da arvore de conte�dos

 # Esse m�todo dever� ser otimizado
 # uma id�ia �
 # ler todos os descendentes do conte�do atual 
 # --> pode ja receber isso pois a� o controle ler� tudo s� uma vez
 # --> pode ler o conte�do ( o necess�rio dele ) j� com as permiss�es o que � melhor ainda...
 # roda pelas permiss�es dos descendentes e remove as subarvores que n�o herdarem essa permissao espec�fica
 # da um update geral por ids em todos os que sobraram. 
 def atualiza_filhos
   self.conteudo.children.each do |c|
     permissao = CaPermissao.find(:first,:conditions=>['conteudo_id=? AND grupo_id=? AND papel_id=?',c.id,self.grupo_id,self.papel_id])
     if permissao.nil?
       permissao = CaPermissao.new({
                                       'grupo_id' => self.grupo_id,
                                       'papel_id' => self.papel_id,
                                       'conteudo_id' => c.id,
                                       'herdar' => true,
                                       'tem_acesso' => self.tem_acesso
                                     })
       permissao.gravar
       permissao.atualiza_filhos
     else
       if(permissao.herdar) 
         permissao.tem_acesso = self.tem_acesso
         #puts('-----------------atualizado:')
         #pp(permissao)
         permissao.gravar
         permissao.atualiza_filhos
       end
     end
   end
 end 

 def atualiza_filhos_recursivo(conteudo)
   conteudo.children.each
 end
 
 def herdar_valor
   pai_do_conteudo = self.conteudo.parent
   if(pai_do_conteudo)
     #veja que herda o valor do pai, mesmo que o pai herde tamb�m, por isso a tabela deve estar sempre integra
     permissao = pai_do_conteudo.permissao_por_grupo_e_papel(self.grupo_id,self.papel_id)
     self.tem_acesso = permissao.tem_acesso
   else
     # se o conteudo nao tem pai, n�o pode herdar valor, por padrao restringe o acesso 
     self.herdar = false
     self.tem_acesso = false
     false
   end
 end


 ####################### métodos de gravação, pois há 3 chaves primárias

 def gravar_novo
   @@count_gravar_novo += 1
   puts('gravar_novo' << @@count_gravar_novo.to_s)
   #pp self
   herdar = self.herdar ? '1' : '0'
   tem_acesso = self.tem_acesso ? '1' : '0'
   sql = "insert into permissao(grupo_id,papel_id,conteudo_id,herdar,tem_acesso) values (
    #{self.grupo_id},
    #{self.papel_id},
    #{self.conteudo_id},
    #{herdar},
    #{tem_acesso}
   )" 
   self.connection.update(sql)
 end

 def gravar
   if self.nova?
     self.gravar_novo
   else
     @@count_gravar += 1
     puts('gravar' << @@count_gravar.to_s)
     #pp self
     herdar = self.herdar ? '1' : '0'
     tem_acesso = self.tem_acesso ? '1' : '0'
     sql = "update permissao set 
                               herdar = #{herdar}, 
                               tem_acesso= #{tem_acesso}
                            where 
                               grupo_id = #{self.grupo_id} AND 
                               papel_id = #{self.papel_id} AND 
                               conteudo_id = #{self.conteudo_id}"
     self.connection.update(sql)
   end
 end
end
